using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Text;
using System.Configuration;
using System.Net.Mail;
using System.Security.Cryptography;
using System.IO;
using System.Globalization;
using System.Net;

namespace BE
{
    public class Configuracion
    {
        public static String GetConnection
        {
            get { return ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString; }
        }
        public static String Attach
        {
            get { return ConfigurationManager.AppSettings["Attach"]; }
        }
        public static String EmailFrom
        {
            get { return ConfigurationManager.AppSettings["EmailFrom"]; }
        }
        public static String EmailPassword
        {
            get { return ConfigurationManager.AppSettings["EmailPassword"]; }
        }
        public static String Uploads
        {
            get { return ConfigurationManager.AppSettings["Uploads"]; }
        }
        public static String SmtpServer
        {
            get { return ConfigurationManager.AppSettings["SmtpServer"]; }
        }
        public static String ObtenerFormatoFecha(DateTime dtFecha)
        {
            return dtFecha.Day.ToString() + DateTimeFormatInfo.CurrentInfo.GetMonthName(dtFecha.Month).ToUpper() + dtFecha.Year.ToString();
        }
        public static String ObtenerFormatoFechaCompleto(DateTime dtFecha)
        {
            String strDayName = DateTimeFormatInfo.CurrentInfo.GetDayName(dtFecha.DayOfWeek).ToUpper();
            return "LIMA, " + strDayName + " " + dtFecha.Day.ToString() + " DE " + DateTimeFormatInfo.CurrentInfo.GetMonthName(dtFecha.Month).ToUpper() + " DEL " + dtFecha.Year.ToString();
        }
        public static String GeneratePassword()
        {
            double dbNewPsswd, dbPower;
            String strPassword = String.Empty;
            //double dbPower;
            uint intNewPsswd;
            Random rnd = new Random();
                        
            // Generating a random password
            dbNewPsswd = rnd.NextDouble();
            dbPower = System.Math.Pow(10, 8);
            intNewPsswd = (uint)(((1 + dbPower * 99) * dbNewPsswd) + dbPower);

            strPassword = intNewPsswd.ToString();
            return strPassword;           
        }

        public static void SendEmail(String strUsuarioEmail,String strSubject,String strBody, String File)
        {                       
            try
            {
                MailMessage message = new MailMessage(EmailFrom, strUsuarioEmail);
                message.Body = strBody;
                message.BodyEncoding = System.Text.Encoding.UTF8;
                message.IsBodyHtml = true;
                message.Subject = strSubject;
                
                Attachment data = new Attachment(File);
                
                // Add the file attachment to this e-mail message.
                message.Attachments.Add(data);

                SmtpClient smtpClient = new SmtpClient();
                // Setting SMTP Default credentials to false
                smtpClient.Host = SmtpServer;
                smtpClient.Credentials = new System.Net.NetworkCredential(EmailFrom, EmailPassword);
                smtpClient.EnableSsl = true;
                smtpClient.Port = 587;

                smtpClient.Send(message);
                smtpClient = null;
                data.Dispose();
            }
            catch (Exception ex)
            {
                throw ex;   
            }            
        }
        public static string DecryptString(string Value)
        {
            // Convert strings defining encryption key characteristics into byte
            // arrays. Let us assume that strings only contain ASCII codes.
            // If strings include Unicode characters, use Unicode, UTF7, or UTF8
            // encoding.
            byte[] initVectorBytes = Encoding.ASCII.GetBytes("@1B2c3D4e5F6g7H8");
            byte[] saltValueBytes = Encoding.ASCII.GetBytes("s@1tValue");

            // Convert our ciphertext into a byte array.
            byte[] cipherTextBytes = Convert.FromBase64String(Value);

            // First, we must create a password, from which the key will be 
            // derived. This password will be generated from the specified 
            // passphrase and salt value. The password will be created using
            // the specified hash algorithm. Password creation can be done in
            // several iterations.
            PasswordDeriveBytes password = new PasswordDeriveBytes(
                "Pas5pr@se",
                saltValueBytes,
                "SHA1",
                2);


            // Use the password to generate pseudo-random bytes for the encryption
            // key. Specify the size of the key in bytes (instead of bits).
            byte[] keyBytes = password.GetBytes(256 / 8);

            // Create uninitialized Rijndael encryption object.
            RijndaelManaged symmetricKey = new RijndaelManaged();

            // It is reasonable to set encryption mode to Cipher Block Chaining
            // (CBC). Use default options for other symmetric key parameters.
            symmetricKey.Mode = CipherMode.CBC;

            // Generate decryptor from the existing key bytes and initialization 
            // vector. Key size will be defined based on the number of the key 
            // bytes.
            ICryptoTransform decryptor = symmetricKey.CreateDecryptor(
                keyBytes,
                initVectorBytes);

            // Define memory stream which will be used to hold encrypted data.
            MemoryStream memoryStream = new MemoryStream(cipherTextBytes);

            // Define cryptographic stream (always use Read mode for encryption).
            CryptoStream cryptoStream = new CryptoStream(memoryStream,
                decryptor,
                CryptoStreamMode.Read);

            // Since at this point we don't know what the size of decrypted data
            // will be, allocate the buffer long enough to hold ciphertext;
            // plaintext is never longer than ciphertext.
            byte[] plainTextBytes = new byte[cipherTextBytes.Length];

            // Start decrypting.
            int decryptedByteCount = cryptoStream.Read(plainTextBytes,
                0,
                plainTextBytes.Length);

            // Close both streams.
            memoryStream.Close();
            cryptoStream.Close();

            // Convert decrypted data into a string. 
            // Let us assume that the original plaintext string was UTF8-encoded.
            string plainText = Encoding.UTF8.GetString(plainTextBytes,
                0,
                decryptedByteCount);

            // Return decrypted string.   
            return plainText;

        }

        public static string CryptString(string Value)
        {
            // Convert strings into byte arrays.
            // Let us assume that strings only contain ASCII codes.
            // If strings include Unicode characters, use Unicode, UTF7, or UTF8 
            // encoding.
            byte[] initVectorBytes = Encoding.ASCII.GetBytes("@1B2c3D4e5F6g7H8");
            byte[] saltValueBytes = Encoding.ASCII.GetBytes("s@1tValue");

            // Convert our plaintext into a byte array.
            // Let us assume that plaintext contains UTF8-encoded characters.
            byte[] plainTextBytes = Encoding.UTF8.GetBytes(Value);

            // First, we must create a password, from which the key will be derived.
            // This password will be generated from the specified passphrase and 
            // salt value. The password will be created using the specified hash 
            // algorithm. Password creation can be done in several iterations.
            PasswordDeriveBytes password = new PasswordDeriveBytes(
                "Pas5pr@se",
                saltValueBytes,
                "SHA1",
                2);

            // Use the password to generate pseudo-random bytes for the encryption
            // key. Specify the size of the key in bytes (instead of bits).
            byte[] keyBytes = password.GetBytes(256 / 8);

            // Create uninitialized Rijndael encryption object.
            RijndaelManaged symmetricKey = new RijndaelManaged();

            // It is reasonable to set encryption mode to Cipher Block Chaining
            // (CBC). Use default options for other symmetric key parameters.
            symmetricKey.Mode = CipherMode.CBC;

            // Generate encryptor from the existing key bytes and initialization 
            // vector. Key size will be defined based on the number of the key 
            // bytes.
            ICryptoTransform encryptor = symmetricKey.CreateEncryptor(
                keyBytes,
                initVectorBytes);

            // Define memory stream which will be used to hold encrypted data.
            MemoryStream memoryStream = new MemoryStream();

            // Define cryptographic stream (always use Write mode for encryption).
            CryptoStream cryptoStream = new CryptoStream(memoryStream,
                encryptor,
                CryptoStreamMode.Write);
            // Start encrypting.
            cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);

            // Finish encrypting.
            cryptoStream.FlushFinalBlock();

            // Convert our encrypted data from a memory stream into a byte array.
            byte[] cipherTextBytes = memoryStream.ToArray();

            // Close both streams.
            memoryStream.Close();
            cryptoStream.Close();

            // Convert encrypted data into a base64-encoded string.
            string cipherText = Convert.ToBase64String(cipherTextBytes);

            // Return encrypted string.
            return cipherText;
        }
    }
}
